package comm

import (
	"errors"
	"regexp"
	"strconv"
)

// QuotedInt 使用外围引号包围的整数类型，用于json解析
type QuotedInt int

// UnmarshalJSON 自定义json解析方法
func (m *QuotedInt) UnmarshalJSON(p []byte) error {
	if len(p) <= 0 {
		return errors.New("无效的数字：" + string(p))
	}
	if p[0] == byte('"') {
		if len(p) <= 2 || p[len(p)-1] != byte('"') {
			return errors.New("无效的数字：" + string(p))
		}
		p = p[1 : len(p)-1]
	}
	ts, err := strconv.ParseInt(string(p), 10, 64)
	if err != nil {
		return err
	}
	*m = QuotedInt(int(ts))
	return nil
}

// MustParseInt 解析整数，如果解析失败返回0
func MustParseInt(s string) int64 {
	d, e := strconv.ParseInt(s, 10, 64)
	if e != nil {
		return 0
	}
	return d
}

// MustParseFloat 解析浮点数，解析失败返回0
func MustParseFloat(s string) float64 {
	d, e := strconv.ParseFloat(s, 64)
	if e != nil {
		return 0
	}
	return d
}

var numberPattern = regexp.MustCompile("\\d+(\\.\\d*)?[万|亿]?")

// ParseFirstFloat 解析字符串中的第一个数字，支持：万、亿
func ParseFirstFloat(s string) float64 {
	s = numberPattern.FindString(s)
	if s != "" {
		return ParseAbbrFloat(s)
	}
	return 0.0
}

// ParseAbbrInt 解析带中文的数字，支持：万、亿
func ParseAbbrInt(s string) int64 {
	rs := []rune(s)
	if len(rs) == 0 {
		return 0
	}
	if rs[len(rs)-1:][0] == '万' {
		s = string(rs[:len(rs)-1])
		return 1e4 * MustParseInt(s)
	}
	if rs[len(rs)-1:][0] == '亿' {
		s = string(rs[:len(rs)-1])
		return 1e8 * MustParseInt(s)
	}
	return MustParseInt(s)
}

// ParseAbbrFloat 解析带中文的数字，支持：万、亿
func ParseAbbrFloat(s string) float64 {
	rs := []rune(s)
	if len(rs) == 0 {
		return 0
	}
	if rs[len(rs)-1:][0] == '万' {
		s = string(rs[:len(rs)-1])
		return 1e4 * MustParseFloat(s)
	}
	if rs[len(rs)-1:][0] == '亿' {
		s = string(rs[:len(rs)-1])
		return 1e8 * MustParseFloat(s)
	}
	return MustParseFloat(s)
}
